package lwq

import (
	"encoding/json"
	"fmt"
	"strings"
	"time"
)

type Wb_文本 struct {
}

func (*Wb_文本) XZW_寻找文本(原始文本, 寻找文本 string) (位置 int) {
	位置 = strings.Index(原始文本, 寻找文本)
	return
}
func (*Wb_文本) DWB_到文本(转换参数 any) (返回_值 string) {
	返回_值 = any_到文本(转换参数)
	return
}

func (*Wb_文本) XZW_寻找文本_到位置数组_正向找(原始文本, 寻找文本 string) (返回_值 []int) {
	次数 := strings.Count(原始文本, 寻找文本)
	位置 := 0
	累计位置 := 0
	for i := 0; i < 次数; i++ {
		位置 = strings.Index(原始文本[累计位置:], 寻找文本)

		if 位置 < 0 {
			return
		}
		累计位置 = 累计位置 + 位置
		返回_值 = append(返回_值, 累计位置)
		累计位置 = 累计位置 + len(寻找文本)
	}
	return
}
func (*Wb_文本) XZW_寻找文本_到位置数组_逆向找(原始文本, 寻找文本 string) (返回_值 []int) {
	次数 := strings.Count(原始文本, 寻找文本)
	位置 := len(原始文本)
	for i := 0; i < 次数; i++ {
		位置 = strings.LastIndex(原始文本[:位置], 寻找文本)
		if 位置 < 0 {
			return
		}
		返回_值 = append(返回_值, 位置)
	}
	return
}

// @返回字符串 原始文本 中字符串  寻找文本 最后一次出现的位置
func (*Wb_文本) XZW_寻找文本_倒找(原始文本, 寻找文本 string) (位置 int) {
	位置 = strings.LastIndex(原始文本, 寻找文本)
	return
}

//	文本_取左边
//
// @原始文本 被取的文本
// @寻找文本 关键词
// @启始寻找位置  <0 为 从右往左边  一个汉字 3个位置
func (类 *Wb_文本) QWB_取文本_左边(原始文本, 寻找文本 string, 启始位置 ...int) (结果 string) {

	启始寻找位置 := 0
	if len(启始位置) > 0 {
		启始寻找位置 = 启始位置[0]
	}
	if 启始寻找位置 > len(原始文本) || -启始寻找位置 > len(原始文本) {
		return
	}
	var 位置组 = make([]int, 0)
	if 启始寻找位置 < 0 {
		启始寻找位置 = len(原始文本) + 启始寻找位置
		位置组 = 类.XZW_寻找文本_到位置数组_逆向找(原始文本, 寻找文本)
		if len(位置组) == 0 {
			return
		}

	} else {
		位置组 = 类.XZW_寻找文本_到位置数组_正向找(原始文本, 寻找文本)
		if len(位置组) == 0 {
			return
		}
	}
	for _, v := range 位置组 {
		if v >= 启始寻找位置 {
			结果 = 原始文本[:v]
			return
		}

	}
	return
}

//	文本_取右边
//
// @原始文本 被取的文本
// @寻找文本 关键词
// @启始寻找位置  -1 为 从右往左边  一个汉字 3个位置
func (类 *Wb_文本) QWB_取文本_右边(原始文本, 寻找文本 string, 启始位置 ...int) (结果 string) {

	启始寻找位置 := 0
	if len(启始位置) > 0 {
		启始寻找位置 = 启始位置[0]
	}
	if 启始寻找位置 > len(原始文本) || -启始寻找位置 > len(原始文本) {
		return
	}

	var 位置组 = make([]int, 0)
	if 启始寻找位置 < 0 {
		启始寻找位置 = len(原始文本) + 启始寻找位置
		位置组 = 类.XZW_寻找文本_到位置数组_逆向找(原始文本, 寻找文本)
		if len(位置组) == 0 {
			return
		}

	} else {
		位置组 = 类.XZW_寻找文本_到位置数组_正向找(原始文本, 寻找文本)
		if len(位置组) == 0 {
			return
		}
	}
	寻找文本_长度 := len(寻找文本)
	for _, v := range 位置组 {
		if v >= 启始寻找位置 {

			结果 = 原始文本[v+寻找文本_长度:]
			return
		}

	}
	return
}

func (*Wb_文本) QWB_取文本_中间(原始文本, 开始文本, 结束文本 string, 取第几个结束文本 ...int) (结果 string) {
	结束符号位 := 1
	if len(取第几个结束文本) > 0 {
		结束符号位 = 取第几个结束文本[0]
	}
	结果 = ""
	位置开始 := strings.Index(原始文本, 开始文本)
	if 位置开始 < 0 {
		return
	}
	判断文本 := 原始文本[位置开始+len(开始文本):]
	循环次数 := 0
	for strings.Contains(判断文本, 结束文本) {
		循环次数++
		位置结束 := strings.Index(判断文本, 结束文本)
		当前值 := 判断文本[:位置结束]
		结果 = 结果 + 当前值
		if 循环次数 == 结束符号位 {
			return
		}
		结果 = 结果 + 结束文本
		判断文本 = 判断文本[位置结束+len(结束文本):]
	}
	结果 = ""
	return
}

func (*Wb_文本) QWB_取文本_出现次数(原始文本, 寻找文本 string) (次数 int) {

	次数 = strings.Count(原始文本, 寻找文本)
	return
}

func (*Wb_文本) QHZ_取汉字(原始文本 string) string{
	var 正则 ZZ_正则
	正则.C_创建("[\u4e00-\u9fa5]+")
	列:=正则.P_匹配列表(原始文本)
	return 列.HBD_合并到文本("")
}

// 通过 {1},{2},{3} 进行站为替换对应文本位置
func (*Wb_文本) CJWB_创建文本(原始文本 string, 对应文本 ...any) (返回值 string) {
	返回值 = c_创建文本(原始文本, 0, 对应文本...)
	return
}

func (*Wb_文本) FGW_分割文本(原始文本, 分割字符 string) (返回切片 []string) {
	if 原始文本 == "" {
		返回切片 = make([]string, 0)
		return
	}
	返回切片 = strings.Split(原始文本, 分割字符)
	return
}
func (*Wb_文本) FGW_分割文本_空白符(原始文本 string) (返回切片 []string) {
	返回切片 = strings.Fields(原始文本)
	return
}

func (*Wb_文本) HBW_合并文本_切片(原始文本 []string, 合并连接符 string) (结果 string) {
	结果 = strings.Join(原始文本, 合并连接符)
	return
}

// @W_文本_子文本替换
//
//	@替换次数 <0 或 大于存在数 为替换全部
//
// @从左往右边  true   重右到左 则填false
func (*Wb_文本) WBT_文本替换_有方向(原始文本, 被替换字符, 替换字符 string, 替换次数 int, 从左往右边 bool) (返回值 string) {
	存在数量 := strings.Count(原始文本, 被替换字符)
	if 存在数量 == 0 {
		return 原始文本
	}
	if 替换次数 < -0 || 替换次数 >= 存在数量 {
		返回值 = strings.Join(strings.Split(原始文本, 被替换字符), 替换字符)
		return
	}
	if 替换次数 > 0 {
		if !从左往右边 {
			返回值 = 原始文本
			for i := 0; i < 替换次数; i++ {
				位置 := strings.LastIndex(返回值, 被替换字符)
				返回值 = 返回值[:位置] + 替换字符 + 返回值[位置+len(被替换字符):]
			}
			return
		} else {
			返回值 = 原始文本
			for i := 0; i < 替换次数; i++ {
				位置 := strings.Index(返回值, 被替换字符)
				返回值 = 返回值[:位置] + 替换字符 + 返回值[位置+len(被替换字符):]
			}
			return

		}
	}
	return 原始文本
}

// @将字符串 原始文本 前n个不重叠  被替换字符 子串都替换为  替换字符 的新字符串
// @如果n<0会替换所有old子串。
func (*Wb_文本) WBT_文本替换(原始文本, 被替换字符, 替换字符 string, 替换次数 int) (返回值 string) {

	返回值 = strings.Replace(原始文本, 被替换字符, 替换字符, 替换次数)
	return
}
func (*Wb_文本) PDQ_判断前缀(原始文本, 前缀文本 string) (返回值 bool) {
	返回值 = strings.HasPrefix(原始文本, 前缀文本)
	return
}
func (*Wb_文本) PDH_判断后缀(原始文本, 后缀文本 string) (返回值 bool) {
	返回值 = strings.HasSuffix(原始文本, 后缀文本)
	return
}
func (*Wb_文本) PDC_判断存在(原始文本, 寻找文本 string) (返回值 bool) {
	返回值 = strings.ContainsAny(原始文本, 寻找文本)
	return
}

// @判断字符串s是否包含unicode的码值r
func (*Wb_文本) PDC_判断存在_unicode(原始文本 string, 寻找文本 rune) (返回值 bool) {
	返回值 = strings.ContainsRune(原始文本, 寻找文本)
	return
}

// @判断字符串 原始文本 是否包含  寻找文本  字符串中的任意一个字符
func (*Wb_文本) PDC_判断包含(原始文本 string, 寻找文本 string) (返回值 bool) {
	返回值 = strings.ContainsAny(原始文本, 寻找文本)
	return
}

// @判断s和t两个UTF-8字符串是否相等，忽略大小写
func (*Wb_文本) PDC_判断相同_utf8(原始文本, 对比文本 string) (返回值 bool) {
	返回值 = strings.EqualFold(原始文本, 对比文本)
	return
}

/*
@ 按字典顺序比较a和b字符串的大小
@ 如果 a > b，返回一个大于 0 的数
@ 如果 a > b，如果 a == b，返回 0
@ 如果 a < b，返回一个小于 0 的数
*/
func (*Wb_文本) PDZ_判断字典顺(原始文本, 对比文本 string) (返回值 int) {
	返回值 = strings.Compare(原始文本, 对比文本)
	return
}

func (*Wb_文本) DXX_到小写(原始文本 string) (返回值 string) {
	返回值 = strings.ToLower(原始文本)
	return
}
func (*Wb_文本) DDX_到大写(原始文本 string) (返回值 string) {
	返回值 = strings.ToTitle(原始文本)
	return
}

// @将字符串 原始文本 首尾包含在  条件字符 中的任一字符去掉
func (*Wb_文本) SSW_删首尾包含(原始文本, 条件字符 string) (返回值 string) {
	返回值 = strings.Trim(原始文本, 条件字符)
	return
}
func (*Wb_文本) SSB_删首包含(原始文本, 条件字符 string) (返回值 string) {
	返回值 = strings.TrimLeft(原始文本, 条件字符)
	return
}
func (*Wb_文本) SSW_删首文本(原始文本, 条件文本 string) (返回值 string) {
	返回值 = strings.TrimPrefix(原始文本, 条件文本)
	return
}
func (*Wb_文本) SWB_删尾包含(原始文本, 条件字符 string) (返回值 string) {
	返回值 = strings.TrimRight(原始文本, 条件字符)
	return
}
func (*Wb_文本) SWW_删尾文本(原始文本, 条件文本 string) (返回值 string) {
	返回值 = strings.TrimSuffix(原始文本, 条件文本)
	return
}
func (*Wb_文本) SSW_删首尾_空(原始文本 string) (返回值 string) {
	返回值 = strings.TrimSpace(原始文本)
	return
}

func (*Wb_文本) QCF_去重复文本(原始文本 string) string{
	切片 := strings.Split(原始文本, "")
	 返回文本 :=""
	for _, v := range 切片 {
		位置 := strings.Index(原始文本, v)
		if 位置>=0{
			continue
		}
		返回文本=返回文本+v
	}
	return 返回文本
}

func (*Wb_文本) SF_是否_是数字(原始文本 string) bool{
	var 正则 ZZ_正则
	正则.C_创建(`^[0-9]*$`)
	return 正则.J_校验(原始文本)
}


//方法集合

func any_到文本(任意数据 any) (返回_值 string) {
	if 任意数据 == nil {
		return
	}
	switch 当前值 := 任意数据.(type) {
	case string:
		返回_值 = 当前值
		return
	case time.Time:
		返回_值 = 当前值.Format("2006-01-02 15:04:05")
		return
	case map[string]any:
		新数据, _ := 键值列表_深拷贝(当前值)
		转换表 := 键值列表_JSON之前处理(新数据)
		JSON, err := json.Marshal(转换表)
		if err != nil {
			返回_值 = "{}"
			return
		}
		返回_值 = string(JSON)
		return
	case []any:
		新数据, _ := 键值列表_深拷贝(当前值)
		转换表 := 键值列表_JSON之前处理(新数据)
		JSON, err := json.Marshal(转换表)
		if err != nil {
			返回_值 = "[]"
			return
		}
		返回_值 = string(JSON)
		return
	case []map[string]any:
		新数据, _ := 键值列表_深拷贝(当前值)
		转换表 := 键值列表_JSON之前处理(新数据)
		JSON, err := json.Marshal(转换表)
		if err != nil {
			返回_值 = "[]"
			return
		}
		返回_值 = string(JSON)
		return
	case []byte:
		返回_值 = string(当前值)
		return
	case JZB_键值表:
		返回_值 = 当前值.Djson_到JSON()
		return
	case LB_列表:
		返回_值 = 当前值.Djson_到JSON()
		return
	default:
		返回_值 = fmt.Sprintf("%v", 任意数据)
		return
	}
}

func c_创建文本(原始文本 string, 赋值次数 int, 对应文本 ...any) (返回值 string) {
	赋值次数++
	if 赋值次数 > len(对应文本) {
		返回值 = 原始文本
		return
	}

	分割符 := "{" + fmt.Sprintf("%v", 赋值次数) + "}"
	分割组 := strings.Split(原始文本, 分割符)
	for i, v := range 分割组 {
		分割组[i] = c_创建文本(v, 赋值次数, 对应文本...)
	}
	返回值 = strings.Join(分割组, any_到文本(对应文本[赋值次数-1]))
	return
}


